﻿using System;
using System.Collections.Generic;
using Sinacor.Infra.Common.Exceptions;
using Sinacor.Infra.Service.ExceptionHandling;
using System.Text;
using Sinacor.Servico.Bovespa.Ordens.BusinessEntity;
using Sinacor.Servico.Bovespa.Ordens.ResourceAccess;
using Sinacor.Servico.Bovespa.Comum.ResourceAccess;
using Sinacor.Servico.Bovespa.Calendario.ResourceAccess;
using Sinacor.Infra.Service.Common;
using Sinacor.Infra.Common.Validation;
using Sinacor.Infra.Service.Validation;



namespace Sinacor.Servico.Bovespa.Cliente.BusinessLogic
{
    /// <summary>
    /// Cliente
    /// </summary>
    public class Cliente : BaseBusinessLogic
    {
        /// <summary>
        /// Construtor Padrão
        /// </summary>
        public Cliente()
            : base()
        { }

        private const int ERRO_PESQUISA_SEM_RESULTADO = 105000;
        private const int ERRO_CLIENTE_INEXISTENTE_OU_USUARAIOSEMACESSO = 109034;
        private const int ERRO_CLIENTE_FILTROINVALIDO = 103175;
        private const int ERRO_CLIENTE_DESATIVADO = 105001; //incluido - esertorio - 200805021930 - ref issue ID0003694
        private const int ERRO_NEGOCIO_FILHOTE_SEM_RELACIONAMENTO_BROKER = 15489387; //TODO: Código correto de erro
        private const int ERRO_CLIENTEUSUARIOACESSORINVALIDO = 109012;
        private const int ERRO_CLIENTEUSUARIOACESSORINATIVO = 109013;
        private const int ERRO_CLIENTEUSUARIOACESSORBLOQUEADO = 109014;
        private const int ERRO_CLIENTEFILHOTEINVALIDO = 109015;
        private const int ERRO_CLIENTEBROKERINVALIDO = 109016;
        private const int ERRO_CLIENTEORDEMLOTEINVALIDO = 109017;
        private const int ERRO_CLIENTEINEXISTENTE = 109351;
        private const int ERRO_CLIENTEINEXISTENTEE = 109486;


        /// <summary>
        /// Historico: Consulta cliente pelo apelido
        /// Data : 04/12/2007
        /// Autor: Eduardo Sertorio
        /// Obs.: Criacao
        /// 
        /// Data : 07/03/2008
        /// Autor: Eduardo Sertorio / Ricardo Valadão
        /// Obs. : Alterado ValidationException por BusinessException para ERRO_PESQUISA_SEM_RESULTADO
        /// 
        /// Data : 09/04/2008
        /// Autor: Eduardo Sertorio
        /// Obs. : Incluido parametro de entrada (digitoCliente) - ref issue ID0002813
        /// </summary>
        /// <param name="apelidoCliente"></param>
        /// <param name="dataOrdem"></param>
        /// <param name="numeroOrdem"></param>
        /// <param name="numeroOrdemSubSequencia"></param>
        /// <param name="digitoCliente"></param>
        /// <returns></returns>
        public BusinessEntity.Cliente ConsultarClienteApelido(string apelidoCliente, DateTime? dataOrdem, Int32? numeroOrdem, Int32? numeroOrdemSubSequencia, Int32? digitoCliente) //Incluido parametro de entrada (digitoCliente) - esertorio - 200804091100 - ref issue ID0002813
        {
            ValidationException _validationException = new ValidationException();
            BusinessEntity.Cliente beCliente = (new ResourceAccess.Cliente()).ConsultarPorApelido(apelidoCliente, true, digitoCliente); //incluido parametro (digitoCliente) - esertorio - 200804091100 - ref issue ID0002813

            if (beCliente == null)
            {
                //alterado ValidationException por BusinessException para ERRO_PESQUISA_SEM_RESULTADO - eduardo sertorio / ricardo valadao - 200803071704
                //_validationException.AddError(ERRO_PESQUISA_SEM_RESULTADO);
                //throw _validationException;
                ////return null;
                throw new BusinessException(ERRO_CLIENTE_INEXISTENTE_OU_USUARAIOSEMACESSO);
            }
            else if (!beCliente.Situacao.HasValue || beCliente.Situacao.Value != Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Enum.TipoSituacao.Ativo) //incluido - esertorio - 200805022018 - ref issue ID0003694
            {
                throw new BusinessException(ERRO_CLIENTE_DESATIVADO); //incluido - esertorio - 200805021930 - ref issue ID0003694
            }


            #region Obtem_TipoLiquidacao_Carteira

            beCliente.TipoLiquidacao = null;
            beCliente.Carteira = null;

            if (dataOrdem.HasValue && (numeroOrdem.HasValue && numeroOrdem > 0) && (numeroOrdemSubSequencia.HasValue))
            {
                //select IN_CAR888 from torparm;
                string TORPARM__IN_CAR888 = new Sinacor.Servico.Bovespa.Comum.ResourceAccess.Parametros().RecuperarIndicadorTipoLiquidacaoCustodianteAutomatico();

                Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Ordem beOrdem = new Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Ordem();
                beOrdem.DataOrdem = dataOrdem;
                beOrdem.NumeroOrdem = numeroOrdem;
                beOrdem.NumeroOrdemSubSequencia = numeroOrdemSubSequencia;
                beOrdem = (new Sinacor.Servico.Bovespa.Ordens.ResourceAccess.Ordem()).ConsultarOrdem(beOrdem);
                if (beOrdem == null)
                {
                    //alterado ValidationException por BusinessException para ERRO_PESQUISA_SEM_RESULTADO - eduardo sertorio / ricardo valadao - 200803071704
                    //_validationException.AddError(ERRO_PESQUISA_SEM_RESULTADO);
                    //throw _validationException;
                    throw new BusinessException(ERRO_PESQUISA_SEM_RESULTADO);
                }

                //If bCar888
                if (!String.IsNullOrEmpty(TORPARM__IN_CAR888) && TORPARM__IN_CAR888.Equals("S"))
                {
                    //If (nClieInst != 0) and (nClieInst >  0)
                    if (beCliente.CodigoClienteInstitucional.HasValue
                        && !beCliente.CodigoClienteInstitucional.Value.Equals(0))
                    {
                        //If tblTorordmega.colMercado = 'VIS'
                        if (!(beOrdem.TipoMercado.Equals(Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Enum.TipoMercado.Vista)
                            //OR tblTorordmega.colMercado = 'FRA'
                            || beOrdem.TipoMercado.Equals(Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Enum.TipoMercado.Fracionario)
                            //OR tblTorordmega.colMercado = 'EOC'
                            || beOrdem.TipoMercado.Equals(Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Enum.TipoMercado.ExercicioOpcaoCompra)
                            //OR tblTorordmega.colMercado = 'EOV'
                            || beOrdem.TipoMercado.Equals(Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Enum.TipoMercado.ExercicioOpcaoVenda)
                            //OR tblTorordmega.colMercado = 'LEI'
                            || beOrdem.TipoMercado.Equals(Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Enum.TipoMercado.Leilao)
                            //OR tblTorordmega.colMercado = 'EST' //20080504 22:42 - RValadao - Bug 3642
                            || beOrdem.TipoMercado.Equals(Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Enum.TipoMercado.Estruturado)) //20080504 22:42 - RValadao - Bug 3642
                        )
                        {
                            //Call oTorordmega.fChangeStrAttribute('Inliquida', 'C')
                            beCliente.TipoLiquidacao = Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Enum.TipoLiquidacao.Custodiante;
                        }
                        //Else [If tblTorordmega.colMercado = 'VIS' OR ...]
                        else
                        {
                            //Call oTorordmega.fChangeStrAttribute('Inliquida', '')
                            beCliente.TipoLiquidacao = Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Enum.TipoLiquidacao.Normal;
                        }

                    }
                    //  Else [If (nClieInst != 0) and (nClieInst >  0)]
                    else
                    {
                        //Call oTorordmega.fChangeStrAttribute('Inliquida', '')
                        beCliente.TipoLiquidacao = Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Enum.TipoLiquidacao.Normal;
                    }
                    //Call oTorordmega.fChangeNumberAttribute('Cdcarliq', 0)
                    beCliente.Carteira = 0;
                }
                //Else (If bCar888)
                else
                {
                    //Call oTorordmega.fChangeStrAttribute('Inliquida', '')
                    beCliente.TipoLiquidacao = Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Enum.TipoLiquidacao.Normal;
                }

            }
            #endregion Obtem_TipoLiquidacao_Carteira

            #region Obter_isClienteBroker

            beCliente.isClienteBroker = (new ResourceAccess.Cliente()).ValidarClienteBroker(beCliente.Codigo.Value); //incluido - esertorio - 200804161708 - ref issue ID0003219

            #endregion Obter_isClienteBroker

            return beCliente;
        }

        /// <summary>
        /// Historico:
        /// Data : 30/11/2007
        /// Autor: Ludmilla Modesto 
        /// Obs.: Criado
        /// 
        /// Data: 17/01/2008
        /// Autor: Diogo Milanez
        /// Obs: Renomeado para se adequar ao padrao de nomenclatura
        /// </summary>
        /// <returns></returns>
        public List<BusinessEntity.Cliente> ConsultarClientes(BusinessEntity.Cliente request, Boolean isFinanceiro)
        {
            Boolean isBloqueado;
            List<BusinessEntity.Cliente> responseCollection = null;
            ResourceAccess.Cliente raCliente = new ResourceAccess.Cliente();

            ValidarConsultaClientes(request);

            isBloqueado = new Sinacor.Servico.Bovespa.Comum.ResourceAccess.Parametros().RecuperarInBloqueio() == "S";

            responseCollection = raCliente.ConsultarClientes(request, isBloqueado, isFinanceiro);


            if (responseCollection.Count == 0)
            {
                if (request.Origem == "ERRO_CLIENTE_INEXISTENTE_OU_USUARAIOSEMACESSO")

                    throw new BusinessException(ERRO_CLIENTE_INEXISTENTE_OU_USUARAIOSEMACESSO);

                else

                    throw new BusinessException(ERRO_PESQUISA_SEM_RESULTADO);

            }

            else
                return responseCollection;
        }

        /// <summary>
        /// Data: 17/01/2008
        /// Autor: Diogo Milanez
        /// Obs: Metodo responsavel por verificar se ao menos um item de filtro foi informado
        /// </summary>
        /// <param name="request"></param>
        private void ValidarConsultaClientes(Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Cliente request)
        {
            if (!request.Codigo.HasValue && String.IsNullOrEmpty(request.Apelido) &&
                String.IsNullOrEmpty(request.Nome) && !request.CPFCNPJ.HasValue &&
                String.IsNullOrEmpty(request.CodigoOperacionalCVM))
            {
                ValidationException ex = new ValidationException();
                ex.AddError(ERRO_CLIENTE_FILTROINVALIDO);
                throw ex;
            }
        }

        /// <summary>
        /// Historico:
        /// Data : 30/11/2007
        /// Autor: Ludmilla Modesto 
        /// Obs.: Criado
        /// </summary>
        /// <returns></returns>
        public BusinessEntity.BloqueioCliente VerificarBloqueioCliente(BusinessEntity.BloqueioCliente request)
        {
            BusinessEntity.BloqueioCliente response = null;
            ResourceAccess.Cliente raCliente = new ResourceAccess.Cliente();

            response = raCliente.VerificarBloqueioCliente(request);

            return response;
        }

        /// <summary>
        /// Historico:
        /// Data : 30/11/2007
        /// Autor: Ludmilla Modesto 
        /// Obs.: Criado, metodo que inclui cliente na Tabela TBOCLIENTE
        /// </summary>
        /// <returns></returns>
        public DateTime IncluirClienteOrdem(BusinessEntity.Cliente request)
        {
            DateTime response;
            ResourceAccess.Cliente raCliente = new ResourceAccess.Cliente();

            String dataMovimento;
            Int32 codigoAfinidade;
            Int32 codigoAssessorInicial = 0;
            Int32 codigoAssessorFinal = 999999;
            String codigoCliente = String.Empty;
            String filtroCliente = String.Empty;

            if (!String.IsNullOrEmpty(request.Apelido))
            {
                codigoCliente = request.Apelido.ToUpper();
                filtroCliente = "A";
            }
            else if (request.Codigo != null)
            {
                codigoCliente = Convert.ToString(request.Codigo);
                filtroCliente = "C";
            }

            List<String> param = new List<string>();
            param.Add(String.Empty);
            param.Add(String.Empty);
            param.Add(String.Empty);

            codigoAfinidade = -1;
            dataMovimento = (new Calendario.ResourceAccess.DataMovimento()).RecuperarDataMovimento().ToString("dd-MM-yyyy");

            //ID0004563
            response = raCliente.IncluirClienteOrdem(
                codigoCliente,
                codigoCliente,
                dataMovimento,
                dataMovimento,
                codigoAfinidade,
                codigoAssessorInicial,
                codigoAssessorFinal,
                filtroCliente,
                param);

            return response;
        }

        public void ExcluirClienteOrdem(DateTime dataSistema)
        {
            ResourceAccess.Cliente raCliente = new ResourceAccess.Cliente();
            raCliente.ExcluirClienteOrdem(dataSistema);
        }

        /// <summary>
        /// Historico:
        /// Data : 13/12/2007
        /// Autor: Ludmilla Modesto 
        /// Obs.: Criado. Metodo que retorna o codigo do Cliente na atividade de Contas Correntes
        /// </summary>
        /// <returns></returns>
        public Int32 ConsultarCodigoClienteContasCorrentes(BusinessEntity.Cliente request)
        {
            Int32 response;

            ResourceAccess.Cliente raCliente = new ResourceAccess.Cliente();

            response = raCliente.ConsultarCodigoClienteContasCorrentes(request);

            return response;
        }

        /// <summary>
        /// Historico:
        /// Data : 13/12/2007
        /// Autor: Ludmilla Modesto 
        /// Obs.: Criado. Metodo que retorna informações do cliente
        /// </summary>
        /// <returns></returns>
        public BusinessEntity.Cliente ConsultarInformacoesCliente(BusinessEntity.Cliente request)
        {
            BusinessEntity.Cliente response = null;
            ResourceAccess.Cliente raCliente = new ResourceAccess.Cliente();

            ValidarConsultaInformacoesClientes(request);

            response = raCliente.ConsultarInformacoesCliente(request);

            if (response == null)
                throw new BusinessException(ERRO_PESQUISA_SEM_RESULTADO);
            else
                return response;
        }

        //20080423 13:59 - Alterado - DMilanez.7Comm
        private void ValidarConsultaInformacoesClientes(BusinessEntity.Cliente request)
        {
            if (!request.Codigo.HasValue && String.IsNullOrEmpty(request.Apelido))
            {
                throw new ValidationException(ERRO_CLIENTE_FILTROINVALIDO);
            }
        }

        /// <summary>
        /// Historico:
        /// Data : 13/12/2007
        /// Autor: Ludmilla Modesto 
        /// Obs.: Criado. Metodo que retorna o codigo do Cliente na tscclibol
        /// </summary>
        /// <returns></returns>
        public Int32 ConsultarCodigoCliente(BusinessEntity.Cliente request)
        {
            ResourceAccess.Cliente raCliente = new ResourceAccess.Cliente();
            return raCliente.ConsultarCodigoCliente(request.Apelido);
        }

        //Task : 5617
        //Data :10/03/2009
        //Autor:Apsilva
        /// <summary>
        /// Consultar Cliente por Apelido
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public BusinessEntity.Cliente ConsultarPorApelido(BusinessEntity.Parameter.FiltroClientePorApelido request)
        {
            return new ResourceAccess.Cliente().ConsultarPorApelido(request.ApelidoCliente, request.IsListaAssessores);
        }

        /// <summary>
        /// Historico:
        /// Data : 14/12/2007
        /// Autor: Ludmilla Modesto 
        /// Obs.: Criado. Metodo que retorna Emissores de Ordem
        /// </summary>
        /// <returns></returns>
        public List<BusinessEntity.EmissorOrdem> ConsultarEmissorOrdem(BusinessEntity.EmissorOrdem request)
        {
            List<BusinessEntity.EmissorOrdem> responseCollection = null;
            ResourceAccess.Cliente raCliente = new ResourceAccess.Cliente();

            responseCollection = raCliente.ConsultarEmissorOrdem(request);

            return responseCollection;
        }

        /// <summary>
        /// Data: 23.09.2008
        /// Autor: Marcio Belarmino (mbelarmino)
        /// Obs:Consultar Cliente
        /// </summary>
        /// <param name="pConsultarClienteCodigo"></param>
        /// <returns></returns>
        public BusinessEntity.Cliente ConsultarClientePorCodigo(BusinessEntity.Parameter.ConsultarClientePorCodigo pConsultarClienteCodigo)
        {
            ResourceAccess.Cliente raCliente = new ResourceAccess.Cliente();
            return raCliente.ConsultarPorCodigo(pConsultarClienteCodigo.CodigoCliente);
        }

        /// <summary>
        /// Data: 23.09.2008
        /// Autor: Marcio Belarmino (mbelarmino)
        /// Obs:Consultar Agente Custodia
        /// </summary>
        /// <param name="pConsultarClienteCodigo"></param>
        /// <returns></returns>
        public BusinessEntity.AgenteCustodia ConsultarAgenteCustodia(BusinessEntity.Parameter.ConsultarClientePorCodigo pConsultarClienteCodigo)
        {
            ResourceAccess.Cliente raCliente = new ResourceAccess.Cliente();
            return raCliente.ConsultarAgenteCustodia(pConsultarClienteCodigo);
        }

        /// <summary>
        /// Data: 23.09.2008
        /// Autor: Marcio Belarmino (mbelarmino)
        /// Obs:Consultar Usuario Institucional
        /// </summary>
        /// <param name="pConsultarClienteCodigo"></param>
        /// <returns></returns>
        public BusinessEntity.UsuarioInstitucional ConsultarUsuarioInstitucional(BusinessEntity.Parameter.ConsultarClientePorCodigo pConsultarClienteCodigo)
        {
            ResourceAccess.Cliente raCliente = new ResourceAccess.Cliente();
            return raCliente.ConsultarUsuarioInstitucional(pConsultarClienteCodigo);
        }


        /// <summary>
        /// Data: 23.09.2008
        /// Autor: Marcio Belarmino (mbelarmino)
        /// Obs:Consultar Cliente
        /// </summary>
        /// <param name="pValidarClienteBroker"></param>
        /// <returns></returns>
        public bool ValidarClienteBroker(
            BusinessEntity.Parameter.ConsultarClientePorCodigo pValidarClienteBroker)
        {
            ResourceAccess.Cliente raCliente = new ResourceAccess.Cliente();
            return raCliente.ValidarClienteBroker(pValidarClienteBroker.CodigoCliente);
        }


        /// <summary>
        /// Data: 26/08/2008
        /// Autor: Valdenir Vanalli Filho (vvanalli.7comm)
        /// Observações: Criação do método
        /// </summary>
        /// <param name="parameter"></param>
        public void ValidarFilhote(Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Parameter.ValidarFilhote parameter)
        {
            bool retorno;
            int iCodigoBroker;
            Sinacor.Servico.Bovespa.Cliente.ResourceAccess.Cliente accessResource = new Sinacor.Servico.Bovespa.Cliente.ResourceAccess.Cliente();

            iCodigoBroker = accessResource.ValidarFilhoteRelacionamentoBroker(parameter);

            if (iCodigoBroker == parameter.CodigoCliente)
            {
                //Regra 2                
                Sinacor.Servico.Bovespa.ResumoFinanceiro.BusinessLogic.Comitente comitenteBusinessLogic = new Sinacor.Servico.Bovespa.ResumoFinanceiro.BusinessLogic.Comitente();
                Sinacor.Servico.Bovespa.ResumoFinanceiro.BusinessEntity.Parameter.ValidarOperacaoFilhote validarOperacaoFilhote = new Sinacor.Servico.Bovespa.ResumoFinanceiro.BusinessEntity.Parameter.ValidarOperacaoFilhote();

                validarOperacaoFilhote.CodigoFilhote = parameter.CodigoFilhote;
                validarOperacaoFilhote.DataPregao = parameter.DataPregao;

                retorno = comitenteBusinessLogic.ValidarOperacaoFilhote(validarOperacaoFilhote);
            }
            else
            {
                //Regra 1.1
                Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Parameter.ValidarBrokerIntermediario parameterBroker = new Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Parameter.ValidarBrokerIntermediario();
                parameterBroker.CodigoBrokerPrincipal = parameter.CodigoCliente;
                parameterBroker.CodigoBrokerIntermediario = iCodigoBroker;

                retorno = accessResource.ValidarFilhoteRelacionamentoBrokerIntermediario(parameterBroker);
            }

            if (!retorno)
            {
                ValidationException ex = new ValidationException(ERRO_NEGOCIO_FILHOTE_SEM_RELACIONAMENTO_BROKER);
            }
        }


        /// <summary>
        /// Data: 23.09.2008
        /// Autor: Marcio Belarmino (mbelarmino)
        /// Obs: Validar Cliente Filhote
        /// </summary>
        /// <param name="pValidarClienteFilhote"></param>
        /// <returns></returns>
        public bool ValidarClienteFilhote(BusinessEntity.Parameter.ValidarClienteFilhote pValidarClienteFilhote)
        {
            ResourceAccess.Cliente raCliente = new ResourceAccess.Cliente();
            return raCliente.ValidarClienteFilhote(pValidarClienteFilhote.CodigoClienteDigitacao, pValidarClienteFilhote.CodigoClienteOrdem);

        }

        public ValidationResult ValidarCliente(BusinessEntity.Parameter.ValidarCliente pValidarCliente)
        {

            bool blDiscricionaria;


            /// <summary>
            /// Verifica se o cliente esta na lista de acessores referente
            /// ao usuario logado.
            /// </summary>
            BusinessEntity.Cliente ClienteUsuarioAcessor = new ResourceAccess.Cliente().ConsultarPorCodigo(pValidarCliente.CodigoCliente);
            if (ClienteUsuarioAcessor == null)
            {
                return new ValidationResult(ValidationErrorFactory.CreateValidationError(ERRO_CLIENTEUSUARIOACESSORINVALIDO));
            }
            /// <summary>
            /// Verifica se o cliente esta ativo 
            /// </summary>
            else if (ClienteUsuarioAcessor.Situacao == BusinessEntity.Enum.TipoSituacao.Inativo)
            {
                return new ValidationResult(ValidationErrorFactory.CreateValidationError(ERRO_CLIENTEUSUARIOACESSORINATIVO));

            }
            /// <summary>
            /// Verifica se o cliente esta bloqueado 
            /// </summary>
            else if (ClienteUsuarioAcessor.Bloqueio.isBloqueado)
            {
                return new ValidationResult(ValidationErrorFactory.CreateValidationError(ERRO_CLIENTEUSUARIOACESSORBLOQUEADO));


            }
            // Considerenado que a ordem Discricionaria não existe 
            blDiscricionaria = false;
            if (pValidarCliente.TipoOrdem != null && pValidarCliente.TipoOrdem == BusinessEntity.Enum.TipoOrdem.Discricionaria)
                blDiscricionaria = true;
            else
                blDiscricionaria = false;




            if (pValidarCliente.CodigoClienteOrdem == pValidarCliente.CodigoClienteOrdemAtual && pValidarCliente.TipoOrdemDistribuicao == BusinessEntity.Enum.TipoOrdemDistribuicao.AdministradoConcorrente)
            {

                return new ValidationResult(ValidationErrorFactory.CreateValidationError(ERRO_CLIENTEORDEMLOTEINVALIDO));

            }
            /// <summary>
            /// Verifica se o Tipo da Ordem/Lote é Discricionária e o TipoOrdemDistribuicao NÃO é AdministradoConcorrente
            /// </summary>
            if (blDiscricionaria == true &&
                pValidarCliente.TipoOrdemDistribuicao != BusinessEntity.Enum.TipoOrdemDistribuicao.AdministradoConcorrente)
            {
                BusinessEntity.Parameter.ValidarClienteFilhote pValidarClienteFilhote = new Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Parameter.ValidarClienteFilhote();

                pValidarClienteFilhote.CodigoClienteDigitacao = pValidarCliente.CodigoCliente;
                pValidarClienteFilhote.CodigoClienteOrdem = pValidarCliente.CodigoClienteOrdem;

                if (!ValidarClienteFilhote(pValidarClienteFilhote))
                    return new ValidationResult(ValidationErrorFactory.CreateValidationError(ERRO_CLIENTEFILHOTEINVALIDO));
                else
                    return new ValidationResult();


            }
            /// <summary>
            /// Verifica se o Tipo da Ordem/Lote é Discricionária e o TipoOrdemDistribuicao é AdministradoConcorrente
            /// </summary>
            else if (blDiscricionaria == true &&
                pValidarCliente.TipoOrdemDistribuicao == BusinessEntity.Enum.TipoOrdemDistribuicao.AdministradoConcorrente)
            {

                BusinessEntity.Parameter.ConsultarClientePorCodigo beBroker = new Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Parameter.ConsultarClientePorCodigo();
                beBroker.CodigoCliente = pValidarCliente.CodigoCliente;



                if (!ValidarClienteBroker(beBroker))
                    return new ValidationResult(ValidationErrorFactory.CreateValidationError(ERRO_CLIENTEBROKERINVALIDO));
                else
                    return new ValidationResult();


            }
            /// <summary>
            /// Caso Contrário, O Cliente deve ser o mesmo da Ordem/Lote
            /// </summary>
            else
            {

                if (pValidarCliente.CodigoClienteOrdem != pValidarCliente.CodigoClienteOrdemAtual)
                {

                    return new ValidationResult(ValidationErrorFactory.CreateValidationError(ERRO_CLIENTEORDEMLOTEINVALIDO));

                }

            }


            return new ValidationResult();


        }

        public ValidationResult ValidarDigitoVerifClienteInstitucional(BusinessEntity.Parameter.ValidarDigitoVerifClienteInstitucional pValidarDigitoVerifClienteInstitucional)
        {

            ResourceAccess.Cliente raCliente = new ResourceAccess.Cliente();
            int? DigVerifCliente = raCliente.GerarDigitoVerifClienteInstitucional(pValidarDigitoVerifClienteInstitucional.CodigoClienteInstitucional, pValidarDigitoVerifClienteInstitucional.CodigoUsuarioInstitucional);
            if (DigVerifCliente == pValidarDigitoVerifClienteInstitucional.DigitoVerifUsuarioInstitucional)
            {
                return new ValidationResult();

            }
            else
            {
                //5451
                //return new ValidationResult(ValidationErrorFactory.CreateValidationError(109005, new List<object> { DigVerifCliente }));
                return new ValidationResult(ValidationErrorFactory.CreateValidationError(109005, new object[]{DigVerifCliente}));

            }

        }

        public BusinessEntity.DependenciaTipoDespesa VerificarDependenciaTipoDespesa(BusinessEntity.Parameter.FiltroDependenciaTipoDespesa parameter)
        {
            ResourceAccess.Cliente _resourceAccess = new ResourceAccess.Cliente();
            return _resourceAccess.VerificarDependenciaTipoDespesa(parameter);
        }
        /// Historico:
        /// Data : 10/08/2009
        /// Autor: Felipe Barbosa Gonzalez
        /// 7Comm Informativa   
        /// Obs.: Criado o metodo ObterCliente
        /// 

        public BusinessEntity.Cliente ObterCliente(BusinessEntity.Parameter.FiltroCliente filtro)
        {
            BusinessEntity.BloqueioCliente beBloqueioCliente = null;
            
            if (filtro == null)
            {
                ValidationException ex = new ValidationException(ERRO_CLIENTEINEXISTENTE);
                throw ex;
            }
            if (filtro.Codigo == null && filtro.Apelido == null || filtro.Apelido == "")
            {
                ValidationException ex = new ValidationException(ERRO_CLIENTEINEXISTENTEE);
            }

            ResourceAccess.Cliente raCliente = new ResourceAccess.Cliente();

            BusinessEntity.Cliente clienteRetorno = raCliente.ObterCliente(filtro);

            if (clienteRetorno != null)
            {
                clienteRetorno.isClienteBroker = raCliente.VerificarClienteBroker(filtro);

                beBloqueioCliente = new BusinessEntity.BloqueioCliente
                {
                    CodigoCliente = clienteRetorno.Codigo
                };

                clienteRetorno.Bloqueio = VerificarBloqueioCliente(beBloqueioCliente);
            }

            return clienteRetorno;
        }

        /// <summary>
        /// Retorna um objeto de Cliente de acordo com os parametros
        /// </summary>
        /// <param name="pConsultarClienteCodigo">Codigo do Cliente</param>
        /// <param name="isListaAcessores">Se é lista de Acessares</param>
        /// <returns>Cliente</returns>
        public BusinessEntity.Cliente ConsultarClientePorCodigo(BusinessEntity.Parameter.ConsultarClientePorCodigo pConsultarClienteCodigo, bool isListaAcessores)
        {
            return new ResourceAccess.Cliente().ConsultarPorCodigo(pConsultarClienteCodigo.CodigoCliente,isListaAcessores);
        }

        /// <summary>
        /// Validação de Cliente já existente
        /// </summary>
        /// <param name="request">Filtro de Cliente</param>
        /// <returns>Resultado da validacao</returns>
        public BusinessEntity.ResultadoValidacaoCliente ValidarExistenciaCliente(BusinessEntity.Parameter.FiltroCodigoCliente request) 
        {
            BusinessEntity.ResultadoValidacaoCliente retorno = new Sinacor.Servico.Bovespa.Cliente.BusinessEntity.ResultadoValidacaoCliente();

            if (request == null)
                throw new BusinessException(109351);

            BusinessEntity.Parameter.ConsultarClientePorCodigo codigo = new Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Parameter.ConsultarClientePorCodigo();
            codigo.CodigoCliente = request.Codigo;
            BusinessEntity.Cliente cliente = this.ConsultarClientePorCodigo(codigo, false);

            retorno.Resultado = new ValidationResult();
            if (cliente == null)
            {
                retorno.Resultado.IsValid = false;
                retorno.Resultado.Error = new ValidationError();
                retorno.Resultado.Error.ErrorNumber = 109344;
                return retorno;
            }
            codigo = new Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Parameter.ConsultarClientePorCodigo();
            codigo.CodigoCliente = request.Codigo;
            cliente = this.ConsultarClientePorCodigo(codigo, true);

            if (cliente == null)
            {
                retorno.Resultado.IsValid = false;
                retorno.Resultado.Error = new ValidationError();
                retorno.Resultado.Error.ErrorNumber = 109345;
                return retorno;
            }
            

            retorno.Resultado.IsValid = true;
            retorno.ApelidoCliente = cliente.Apelido;

            return retorno;
        }

        /// <summary>
        /// ObterEmissorPrincipal
        /// </summary>
        /// <param name="request">Cliente</param>
        /// <returns>EmissorOrdem</returns>
        public BusinessEntity.EmissorOrdem ObterEmissorPrincipal(BusinessEntity.Parameter.FiltroCodigoCliente request)
        {
            return new ResourceAccess.Cliente().ObterEmissorPrincipal(request);
        }

    
        /// <summary>
        /// Metodo responsavel por retornar verdadeiro ou falso se o cliente é Administrador Concorrente (InAdminCon);
        /// </summary>
        /// <param name="codigoCliente"></param>
        /// <returns>bool</returns>
        public bool ValidarClienteAdminCon(int codigoCliente)
        {
            return new ResourceAccess.Cliente().ValidarClienteAdminCon(codigoCliente);
        }
    }
}
